package org.pupil.event;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Description: Rpc服务事件监听执行器的加载器，用于管理监听事件执行器和发送服务事件
 * @Author: pupil
 * @Date: 2024/07/11 下午 3:51
 */
public class RpcListerLoader {
    // 监听事件执行器的线程池，设置2个固定线程
    private static ExecutorService eventThreadPool = Executors.newFixedThreadPool(2);

    //服务事件监听执行器集合
    private static List<IRpcListener> rpcListenList = new ArrayList<>();

    // 初始化服务事件监听事件执行器
    public void init() {
        registerListen(new AddRpcListener());
        registerListen(new DestroyRpcListener());
        registerListen(new UpdateRpcListener());
    }

    // 注册服务事件监听执行器
    private static void registerListen(IRpcListener iRpcListener) {
        rpcListenList.add(iRpcListener);
    }

    // 发送服务事件
    public static void sendEvent(RpcEventData eventData) {
        if (eventData == null) {
            return;
        }

        if (!rpcListenList.isEmpty()) {
            for (IRpcListener iRpcListener : rpcListenList) {
                // 获取接口上的泛型
                final Class<?> generics = getInterfaceGenerics(iRpcListener);
                if (eventData.getClass().equals(generics)){
                    // 开启新线程用于服务事件发送
                    eventThreadPool.execute(()->{
                        iRpcListener.exec(eventData);
                    });
                }
            }
        }
    }

    // 获取服务事件接口上的泛型
    private static Class<?> getInterfaceGenerics(Object o) {
        // 获取类实现的接口对象数组
        Type[] types = o.getClass().getGenericInterfaces();
        // 获取第一个接口
        ParameterizedType parameterizedType = (ParameterizedType) types[0];
        // 获取泛型参数的类型
        Type type = parameterizedType.getActualTypeArguments()[0];
        // 判断并返回泛型参数的类型
        if (type instanceof Class<?>) {
            return (Class<?>) type;
        }
        return null;
    }
}
